A slab form, at its most basic, consists of four parts:
In a real slab form there are at least two other parts, the braces, and the form work for the sides of the slab. You already know about the braces, and you can think of the side forms as just really short walls that are supported with nails at the bottom, and compression braces at the top.
In the image to the right, the shores are green due to being pressure treated. This is not necessary, but I've shown them this way because if you walk into a home center you are most likely to see 4x4s that are green due to being treated.
The image to the left (source) is of a third floor slab form, supported on Ellis Jacks, (note that there are addition eccentricities in the shores). The second floor is being supported by reshores, but that is another topic. Additionally, there are options for shoring$^1$, and even forms$^2$. But, again, if you can understand how to design a slab form out of timber, then you can design one using other systems.
The design procedure is similar to wall forms.
Aside from the fact that there is one additional bearing check we need to make, there is one other difference. That difference is the constructible spacings. When we were looking are wall forms everything we looked at was based around getting the spacings to work out with the size of a sheet of plywood. We only need to design around a sheet of plywood when we are doing the plywood support spacings in slab forms, i.e. the joist spacings. Our joists are not limited to $48"$ and $96"$, instead joists will generally be a standard lumber length. Lumber is typically sold in either $8'$, $10'$, $12'$, $14'$, or $16'$ lengths. This variety means that we will have to decide how long we want the joists to be when we determine their support spacings. For instance if we find that the joists should be supported every $42"$, then instead of rounding down to $32"$ to use an $8'$ long member ($3 \times 32" = 96" = 8'$) we will just use $14'$ long joists ($4 \times 42" = 168" = 14'$). I'll cover an analytically approach of determining this later.
Before we start working on an example problem, I should mention a couple of assumptions I will be making in all slab design problems. Firstly, all joists will be 4x4s. This isn't required in a professional setting, but they are used commonly enough that it isn't an unreasonable assumption. Secondly, all stringers will be 4x6s (oriented in the strong direction). Again, it isn't really required but it is relatively common.
The reason that 4x4s and 4x6s are so common that I can make these assumptions, is that the use such stout members eliminates the need for labor intensive, intermediate blocking. Such blocking would be needed to prevent rollover for taller and thinner members. Let's go ahead, and work through an example problem.
Design formwork for a concrete floor slab based on the following information:
%run Older_Classes/Temp_struc_v_3_beta.py
%run Beams/Timber_beam_v_02.1.py
# %run Beams/Find_Beam_lib.py
In order to display plots inline in the IPython notebook you must include the following magic command: %matplotlib inline If you need to display plot you will need to used the following commmand %matplotlib inline Note: The atribute 'pick_list' is now available_grades (added Jan, 6, 2014) Now using 2015 Timber code by default
t_concrete = 10 #in
DL_form_work = 5.5 #psf
LL = 50 #psf
Wet = True
ply = panel()
#setting the thickness sets the structural properties
#of the plywood automatically
ply.nom_thick='3/4'
ply.group=2
ply.grade='S-2'
ply.condition = "wet"
Species = "HEM-FIR"
Grade = 'Select Structural'
Shore_length = 14 #ft
Shore_section_b = 3.5 #in
Shore_section_d = 5.5 #in
For Bending, span, $L = 10.95 \sqrt{\frac{F_b' S}{w}}$
For Rolling shear in sheathing, span, $L = \frac{20 \times F_s'}{w}\times \frac{I b }{Q}$
For Shear in dimensional lumber, span, $L = 13.33 \times \frac{F_v' b d}{w} + 2 d$
For deflection where $\Delta = {}^L/_{360}$, span, $L = 1.69 \sqrt[3]{\frac{E' I}{w}}$
For deflection where $\Delta = {}^1/_{16}\text{"}$, span, $L = 3.23 \sqrt[4]{\frac{E' I}{w}}$
Stress = Load/Area
DL_fw = DL_form_work
LL = LL
t = t_concrete
SlabLoad = slab_load(t,LL = LL, DL_forms = DL_fw)
p = SlabLoad.value
# p = DL_fw+DL_con+LL
print("Uninform pressure = %.2f psf"%p)
Uninform pressure = 180.50 psf
The load on the slab formwok is made up of, the Concrete Dead Load, the Formwork Dead Load, and the worker Live Load. We need to find the Concrete Dead Load, then calculate the total pressure $(p)$ on the slab formwork.
SlabLoad.work
print('Plywood thickness = %s"'%ply.nom_thick)
print('Plywood group = %s'%ply.group)
print('Plywood stress ratting = %s'%ply.grade)
print('Plywood moisture condition = %s'%ply.condition)
Plywood thickness = 3/4" Plywood group = 2 Plywood stress ratting = S-2 Plywood moisture condition = wet
# OVERRIDE
# ply.F_b = 820 #psi/ft
# ply.F_s = 44 #psi/ft
# ply.E = 1300000 #psi/ft
# ply.C_D = 1.25
Knowing that the plywood is oriented in the strong direction, and our $C_D = 1.25$, we can look up the properties of the plywood in the Plywood Design Specification.
ply.show_props.work
This means that the allowable stresses for the plywood are,
ply.show_allowable_stress.work
w = p
print("w = %.2f plf"%w)
joist_spacing = board_test(ply,w,plywood=True, slab=True)
w = 180.50 plf
Now that we know the properties of the plywood we can calculate the maximum spacing of the joists due to bending, rolling shear, and both deflection limits.
joist_spacing.work
print("Using {} {}\n".format(Grade,Species))
joist=Timber_Beam()
joist.species=Species
joist.C_M.use=Wet
joist.grade=Grade
Using Select Structural HEM-FIR
joist.C_D = 1.25
joist.C_r_setter(joist_spacing.value.inches)
lineload = line_load(p,joist_spacing.value.feet)
w = lineload.value
We need to fine a new value for $w$ based on the joist spacing.
lineload.work
joist.b=3.5
joist.d=3.5
stringer_spacing = board_test(joist,w)
After looking up the value for $F_b$, $F_v$, and $E$ in Table 4A, and also noting the values of $C_F$, $C_M$, and $C_r$, we and go to Table 4.3.1 to determine our allowable stresses. (Every adjustment factor we don't use equals 1.)
joist.F_b_latex
joist.F_v_latex
joist.E_latex
From Table 1B of the Supplement we find that the sections properties of the joists are...
joist.geometry_latex
Now that we know the properties of the joist, we can calculate the maximum spacing of the stringers based on bending, rolling shear, and both deflection limits.
stringer_spacing.work
We get the $4'$ spacing for the stringers based on the following procedure. We divide all the available lumber lengths by the smallest allowable spacing, and determine which one is closest to the next whole number divisor. Round this number up, and divide the corresponding length by that value to determine the optimum spacing. I.e.,
Rounding $1.80$ up to the next whole number we get $2$. We now divide $8'$ by $2$ to determine the optimum spacing.
$$\frac{8'}{2} \times \frac{12"}{1'} = 48"$$Now that we know that our spacing is $4'$ on center we can just pick the cheapest lumber size that is divisible by $4'$, e.g. either $8'$, $12'$, or $16'$ (probably $8'$). This means that we will want to use $8'$ material for our joists.
print("Using {} {}\n".format(Grade,Species))
stringer = Timber_Beam()
stringer.species=Species
stringer.C_D=1.25
stringer.C_M.use=Wet
stringer.grade=Grade
Using Select Structural HEM-FIR
lineload = line_load(p,stringer_spacing.value.feet)
w = lineload.value
We need to fine a new value for $w$ based on the stringer spacing.
lineload.work
stringer.b=3.5
stringer.d=5.5
shore_spacing = board_test(stringer,w)
After looking up the value for $F_b$, $F_v$, and $E$ in Table 4A (we'd use 4B for Southern Pine), and also noting the values of $C_F$, $C_M$, and $C_r$, we go to Table 4.3.1 to determine our allowable stresses. Every adjustment factor we don't use equals 1.
stringer.F_b_latex
stringer.F_v_latex
stringer.E_latex
From Table 1B of the Supplement we get the sections properties for the stringers.
stringer.geometry_latex
Now that we know the properties of the stringers, we can calculate the maximum spacing of the shores based on bending, shear, and both deflection limits.
shore_spacing.work
We get the $56"$ spacing based on the following procedure.
Rounding $2.95$ up to the nearest whole number we get $3$. We now divide $14'$ by $3$ to determine the optimum spacing.
$$\frac{14'}{3} \times \frac{12"}{1'} = 56"$$Since $14'$ is the only size that is dividable by $56"$ we should use $14'$ stringers, (unless you can get a deal, on some other length lumber that is great enough to justify a less than optimum spacing).
s1 = joist_spacing.value.feet
s2 = stringer_spacing.value.feet
c1 = joist.b #contact dimension
c2 = stringer.b #contact dimension
bearing_loads = bearing_info(p, s1, s2, c1, c2, 'joist width', 'stringer width')
A = bearing_loads.area
P = bearing_loads.load
We have to first find the bearing load of the joists on the stringers.
bearing_loads.work
We will have to look up the $F_{c \perp}'$ adjustment factors in Table 4.3.1 and the value for $F_{c \perp}$ and $C_M$ in the Supplement to be able to compare $f_{c \perp}$ to $F_{c \perp}$.
bearing_check(stringer,P,A,board_name="stringers and joist").work
s1 = shore_spacing.value.feet
s2 = stringer_spacing.value.feet
c1 = Shore_section_b #contact dimension
c2 = Shore_section_d #in #contact dimension
bearing_loads = bearing_info(p, s1, s2, c1, c2, 'shore width', "shore depth")
A = bearing_loads.area
P = bearing_loads.load
Now we find the bearing load of the stringers on the shores.
bearing_loads.work
The values for $F_{c \perp}$ and $C_M$ are the same as before. We just need to recalculate $f_{c \perp}$ to be able to compare it to $F_{c \perp}$.
bearing_check(stringer,P,A,board_name="stringer").work
In this problem, the shores are timber columns. As such, we have covered this material earlier this semester, and if you feel confident in solving a timber column, simply go to the next slide where we look at the actual stresses on the shore. Otherwise, click down for a review on how to solve a timber column problem.
print("Using {} {}\n".format(Grade,Species))
shore = Timber_Beam()
shore.P = P #from above
shore.species=Species
shore.C_D=1.25
shore.C_M.use=Wet
shore.grade=Grade
Using Select Structural HEM-FIR
shore.b=Shore_section_b
shore.d=Shore_section_d
shore.L = Shore_length
shore.C_P_l_e.c = 0.8
print('Shore section: b = %.2f", and d = %.2f"'%(shore.b,shore.d))
print('Shore length (unbraced length) = %.2f"'%(Shore_length*12))
Shore section: b = 3.50", and d = 5.50" Shore length (unbraced length) = 168.00"
From Table 1B of the Supplement we get the sections properties of the shores.
shore.geometry_latex
After looking us the value for $F_c$, and $E_{min}$ in Table 4A (we'd use 4B for Southern Pine) and also noting the values of $C_F$, and $C_M$, we and go to Table 4.3.1 to determine our allowable value for $E_{min}$. Every adjustment factor we don't use equals 1.
shore.E_min_latex
shore.C_P.work
shore.F_c_latex
We already found the axial load on the shores. The load is the same as the load found for the bearing stress calculation between the stringers and the shores. The bearing stress is also the same as the compressive stress parallel to grain, but I'll show the calculation again.
shore.f_c_latex
shore.column_adequacy_check_latex
As a mater of curiosity, lets also work out what the shore's capacity is.
shore.column_capacity_brief.work
txt = (r'$$\text{Using %s", Group %s, %s stress rated, plywood, '
%(ply.nom_thick, ply.group, ply.grade))
txt += r'supporting a %g" thick slab,}$$'%(t_concrete)
txt += (r'$$\text{the %s, %s, 4x4 joists need to be spaced at %g" on center,}$$'
%(Grade,Species,joist_spacing.value.inches))
txt += (r'$$\text{the 4x6 stringers need to be spaced at %g" on center,}$$'
%stringer_spacing.value.inches)
D = ceil(Shore_section_d)
B = ceil(Shore_section_b)
txt += r"$$\text{and the %g' tall %dx%d shores "%(Shore_length, B,D)
txt += r'need to be spaced at %g" on center.}$$'%shore_spacing.value.inches
summary = txt
Latex(summary)
Class website (Use this link to if you are taking the course on e-learning.)
Github.io version of course website (Do not use this link if you are taking this course in Summer A or B.)
IPython.org (IPython is the opensource software used in the development of much of this course.)